﻿#region
using System;
using System.Windows;
using YouTubePlaylist.Models;
using YouTubePlaylist.ViewModels;
#endregion

namespace YouTubePlaylist.Views
{
    public partial class PlaylistCtrl : IDisposable
    {
        #region Private fields

        private PlaylistViewModel _vm;

        #endregion

        public PlaylistCtrl()
        {
            InitializeComponent();
            Loaded += OnLoaded;
            ViewModel = new PlaylistViewModel();
        }

        public PlaylistViewModel ViewModel
        {
            get { return _vm; }
            private set
            {
                _vm = value;
                var element = Content as FrameworkElement;
                if (element != null)
                {
                    element.DataContext = _vm;
                }
            }
        }

        #region Playlist dependency property

        public static readonly DependencyProperty PlaylistModelProperty = DependencyProperty.Register("PlaylistModel",
                                                                                                      typeof (
                                                                                                          PlaylistModel),
                                                                                                      typeof (
                                                                                                          PlaylistCtrl),
                                                                                                      new PropertyMetadata
                                                                                                          (null,
                                                                                                           OnPlaylistModelChanged));

        public PlaylistModel PlaylistModel
        {
            get { return (PlaylistModel) GetValue(PlaylistModelProperty); }
            set { SetValue(PlaylistModelProperty, value); }
        }

        private static void OnPlaylistModelChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var ctrl = d as PlaylistCtrl;
            if (ctrl != null)
            {
                ctrl.ViewModel.PlaylistModel = e.NewValue as PlaylistModel;
            }
        }

        #endregion

        #region Private methods

        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            //this.ApplyTheme();
        }

        #endregion

        #region IDisposable

        private bool disposed;

        // Implement IDisposable.
        // Do not make this method virtual.
        // A derived class should not be able to override this method.
        public void Dispose()
        {
            Dispose(true);
            // This object will be cleaned up by the Dispose method.
            // Therefore, you should call GC.SupressFinalize to take this object off the finalization queue
            // and prevent finalization code for this object from executing a second time.
            GC.SuppressFinalize(this);
        }

        // Dispose(bool disposing) executes in two distinct scenarios.
        // If disposing equals true, the method has been called directly or indirectly by a user's code. Managed and unmanaged resources can be disposed.
        // If disposing equals false, the method has been called by the runtime from inside the finalizer and you should not reference other objects. Only unmanaged resources can be disposed.
        private void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.
            if (!disposed)
            {
                // If disposing equals true, dispose all managed and unmanaged resources.
                if (disposing)
                {
                    // Dispose managed resources.
                    var disposable = Player as IDisposable;
                    if (disposable != null)
                    {
                        disposable.Dispose();
                    }
                }
                // Call the appropriate methods to clean up unmanaged resources here.
                // If disposing is false, only the following code is executed.
                // Note disposing has been done.
                disposed = true;
            }
        }

        // Use C# destructor syntax for finalization code.
        // This destructor will run only if the Dispose method does not get called.
        // It gives your base class the opportunity to finalize.
        // Do not provide destructors in types derived from this class.
        ~PlaylistCtrl()
        {
            // Do not re-create Dispose clean-up code here.
            // Calling Dispose(false) is optimal in terms of readability and maintainability.
            Dispose(false);
        }

        #endregion
    }
}